home *** CD-ROM | disk | FTP | other *** search
/ PD ROM 1 / PD ROM Volume I - Macintosh Software from BMUG (1988).iso / Programming / Complete Applications / Othello C Source / othello.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-04-19  |  15.3 KB  |  574 lines  |  [TEXT/ttxt]
  1. /* othello.c */
  2.  
  3. /*
  4.  * This game written for the Macintosh by Steven Munson.
  5.  * Copyright (c) 1984, Steven Munson
  6.  */
  7.  
  8. /* .h files needed by skeleton */
  9.  
  10. #include "mac/quickdraw.h"
  11. #include "mac/osintf.h"
  12. #include "mac/toolintf.h"
  13. #include "othello.h"
  14.  
  15. /*    
  16.     The following two constants are not defined in any .h file.  They
  17.     are described in "Inside Macintosh" - Event Manager, pp. 14-15.
  18.   Well, Sumac defines cmdkey at least.
  19. */
  20. #define CHARCODEMASK 255  
  21.  
  22. #define WINDOWID 260        /* Resource ID for my window */
  23.  
  24. #define RPTBOXID 257        /* ID of our report dialog in resource file */
  25. #define RPTTEXT 2        /* Item # of dialog's report text */
  26.  
  27. typedef long   *lomemptr;    /* a pointer to low memory locations */
  28.  
  29.  
  30. /* our global vars */
  31. struct QDVar qdvar;
  32. GrafPtr ScreenPort;        /* a port for the whole screen */
  33. WindowPtr myWindow;        /* our one window */
  34. WindowRecord wRecord;        /* storage for window record */
  35. Rect DragRect;            /* rect to drag within */
  36. Rect GrowRect;            /* bounds for the growth of the windows */
  37.  
  38. int    trace = 0;
  39. int    curColor = stoneWhite;
  40. int    player[] = {0, Macintosh, Person, 0};        /* color -> player */
  41. char    *playerName[] = {"Macintosh", "Person"};    /* player -> name */
  42. int    nStones[] = {BOARDSIZE*BOARDSIZE, 0, 0, 0};    /* color -> n stones */
  43. char    *colorName[] = {"Empty", "White", "Black", "Edge"};
  44. int    GameOver = FALSE;
  45. int    nClicks = 0;
  46.  
  47.  
  48. /* declare to be paranoid */
  49. /* DoEvent routines */
  50. void doMouse();
  51. void doAutoKey();
  52. void doActivate();
  53. void doUpdate();
  54.  
  55.  
  56.  
  57. /* from Bill Schilit, C.U. */
  58. /*
  59.  * Desk accessories have weird names that begin with a leading zero.
  60.  * Since this fools the automatic C/Pascal string conversion stuff, we
  61.  * have this little gem;  given a C string, it returns a Pascal string
  62.  * with leading zero.  Luckily I know of no other dependencies on embedded
  63.  * zeros in Macintosh strings.
  64.  *
  65.  * NB: causes problems with DA's that don't have leading zero's on their names
  66.  * (e.g. with non apple DA's).
  67.  */
  68.  
  69. char *
  70. DAname(s)
  71. char *s;
  72. {
  73.     static char ps[32];
  74.     int i = 1;
  75.     register char *cp,*dp;
  76.  
  77.     cp = s;
  78.     dp = &ps[2];
  79.     while ((*dp++ = *cp++))
  80.         i++;
  81.     ps[0] = i;
  82.     return (isapstr(ps));
  83. }
  84.  
  85.  
  86. char *
  87. pstrcpy(cStr, hPStr)
  88. char    *cStr;
  89. Handle    hPStr;
  90. {
  91.     register int    length;
  92.     register char    *to, *from;
  93.     
  94.     to = cStr;
  95.     length = **hPStr;
  96.     from = *hPStr + 1;
  97.     for ( ; length > 0; --length)
  98.         *to++ = *from++;
  99.     *to = '\0';
  100.     return (cStr);
  101. }
  102.  
  103.  
  104.  
  105. /* 
  106. Print a string in dialog box
  107. ############################   Report   #################################
  108.  
  109. We put up a dialog box, show the string, and wait for user to hit OK.
  110.  
  111. n.b. for sumac, I believe you reference pascal strings at the start of
  112. the string with the count right before it.  Not sure.  This would account
  113. for the way this routine had to be called.  Also, it is probably best to 
  114. do "rounding" (e.g. fill out to even # of bytes)
  115.  
  116. */
  117.  
  118. report(reportstr)
  119. char *reportstr;
  120. {
  121.     int     itemhit;    /* which Item was clicked on (only OK avail) */
  122.     DialogPtr reportptr;
  123.  
  124.     /* 
  125.         WARNING: paramtext assumes that the strings
  126.         passed to it are Pascal-type, byte-encoded strings,
  127.         instead of C-type, NULL-terminated strings.
  128.         This works here for two reasons: First, getstring()
  129.         returns a handle to the resource, which is in the
  130.         proper format; and second, the Pascal and C style
  131.         empty strings happen to look the same - WHJ 3/11/85
  132.  
  133.         Exercise: Modify Report so that it displays an
  134.         internally generated string instead of a string
  135.         obtained from the resource fork.  Be careful! This
  136.         is pretty straightforward, but you can get stung!
  137.     */
  138.     ParamText (reportstr, "", "", "");/* set text to display */
  139.     reportptr = GetNewDialog (RPTBOXID, NULL, (long) - 1);
  140.  
  141.     /* get from Resource file; NIL => use heap storage;  */
  142.     /* -1 => make dlg frontmost */
  143.  
  144.     /* carry out dialog; NIL => no FilterProc; return item Hit when done */
  145.     ModalDialog (NULL, &itemhit);
  146.  
  147.     /* release storage and remove dialog from screen */
  148.     DisposDialog (reportptr);
  149. }
  150.  
  151.  
  152. /*
  153.  
  154. SetUps for handling memory
  155. ##########################   SetUpMemory   ############################
  156.    This very important set of initializations can be left out of the
  157.    first versions of a program. We are making sure that memory is laid
  158.    out as we desire, with adequate protection against running out of
  159.    memory, bad handles, etc.
  160. */
  161.  
  162. SetUpMemory()
  163. {
  164.     lomemptr nilptr;    /* will have value NIL */
  165.     lomemptr stackbaseptr;    /* points to current stack base */
  166.  
  167.     /* A GrowZone function to handles bad memory problems */
  168.     /*  setgrowzone(&mygrowzone);     */
  169.  
  170.  
  171.     /*  Place a longint -1 (an odd and therefore illegal address) */
  172.     /* in the memory location that would be referenced by an */
  173.     /* accidentally-NULL handle, so the error will be caught */
  174.     /* at handle-reference time (as an Address error, ID=02) instead */
  175.     /* of later on. */
  176.  
  177.     nilptr = NULL;
  178.     *nilptr = -1;
  179.  
  180.     /* If you needed to use an Application heap limit other than the */
  181.     /* default (which allows 8K for the stack), you'd set it here, */
  182.     /* possible using this technique of explicitly specifying the */
  183.     /*  maximum stack size and allocating the rest to the heap.  */
  184.     /* Should be independent of memory size. */
  185.     /* CurStackBase from Tlasm/sysequ.text */
  186.     stackbaseptr = (lomemptr) 0x908;
  187.     SetApplLimit((char *) (*stackbaseptr - MAXSTACKSIZE));
  188.  
  189.  
  190.     /*  Expand the application heap zone to its maximum size, without */
  191.     /* purging any purgeable resources.  This saves memory compactions */
  192.     /* and heap expansions later. */
  193.     MaxApplZone();
  194.  
  195.     /* get plenty of master pointers now; if we let the Memory Manager */
  196.      /* allocate them as needed, they'd form non-relocatable islands in */
  197.     /* the heap.  */
  198.     MoreMasters();
  199.     MoreMasters();
  200.     MoreMasters();
  201.  
  202. /* 
  203.   Here you might install bulwarks against running out of memory
  204.   unexpectedly.  One such (cheesy) technique is to here allocate
  205.   a large handle, call it "CheeseBuf", which you can de-allocate
  206.   in your GrowZone function, when you must obtain more memory to
  207.   avoid a crash.  While de-allocated, the program could prevent
  208.   the user from doing anything requiring memory, and tell him he
  209.   must discard windows or some such memory freeing action. Each
  210.   time he does so, the program can try to re-allocate CheeseBuf;
  211.   if it succeeds, the user can go on doing memory-eating operations.
  212. */
  213.  
  214. }
  215.  
  216. /*
  217.     
  218. body of SetUp
  219. ############################   SetUp   ##############################
  220.  
  221.    Initialize our program.  It seems best to handle:
  222.    Memory inits first, ToolBox inits second, then the program variables'
  223.    inits. Note that the order of inits is important; see "Using the
  224.    Dialog Manager" in the Dialog Mgr section.
  225.  
  226. */
  227.  
  228. SetUp() 
  229. {
  230.     Rect screenrect;    /* screen size; could be machine-dependent */
  231.  
  232.     SetUpMemory();        /*  init memory layout and protection */
  233.  
  234.     /*  init QuickDraw, and everybody else */
  235.     QD = &qdvar;
  236.     InitGraf(&thePort);
  237.     QD->randSeed = TickCount() ;
  238.     InitFonts();
  239.     InitWindows();
  240.     InitMenus();
  241.     TEInit();
  242.     InitDialogs(NULL);    /* NULL => no Restart proc; see Dialog Mgr */
  243.                 /* and System Error Handler */
  244.     InitCursor();
  245.  
  246.     /* 
  247.         Init the system event mask, in case the previous program left
  248.         it in a bad state.  If you set it non-standard here, FIX IT
  249.         BEFORE EXITING, because the Finder (1.1g) does NOT set it.
  250.         */
  251.     SetEventMask(everyEvent - keyUpMask);/* standard setting */
  252.  
  253.     /* 
  254.         Get the port which is the whole screen, to use when deactivating
  255.        our window.  This prevents the current grafPort pointer from
  256.        ever dangling.
  257.     */
  258.     GetWMgrPort(&ScreenPort);    /* get whole screen port that window */
  259.                     /* manager uses... */
  260.     SetPort(ScreenPort);    /* ... and start off with it */
  261.  
  262.     /* 
  263.       get window: use wRecord storage.  Port is set to that of the new
  264.       window.  GetNewWindow posts an update event for the new window, so it
  265.       will be redrawn right away.
  266.     */
  267.     myWindow = GetNewWindow(WINDOWID, &wRecord, (long) - 1);
  268.                 /* -1 => frontmost window */
  269.  
  270.     /* set up dragRect; we can drag the window within it */
  271.     /* don't assume screen size */
  272.     screenrect.top = QD->screenBits.bounds.top;
  273.     screenrect.left = QD->screenBits.bounds.left;
  274.     screenrect.bottom = QD->screenBits.bounds.bottom;
  275.     screenrect.right = QD->screenBits.bounds.right;
  276.  
  277.     /* set drag rect to avoid menu bar */
  278.     SetRect(&DragRect,0,20,screenrect.right,screenrect.bottom);
  279.  
  280.     /* set up GrowRect, for limits on window growing */
  281.     SetRect(&GrowRect,48,14,screenrect.right-7,screenrect.bottom-7);
  282.  
  283.     /* pull in and set up our menus */
  284.     SetUpMenus();
  285.  
  286.     InitBoard();
  287. }
  288.  
  289. /* 
  290. Redraw my window
  291. ############################   DrawWindow   #############################
  292.  
  293.    We draw all the contents of our one window, myWindow.  Note that this
  294.    must include scroll bar areas and the grow icon; the Window Manager
  295.    will NOT handle those for us. Since there are no scroll bars, we
  296.    must erase the region they would be in.  Echh.
  297. */
  298.  
  299. DrawWindow () {
  300.     Rect arect;        /* rectangle to erase */
  301.  
  302.     /*  first, fill the window with white; fills scroll bars, too */
  303.     EraseRect(&myWindow -> portRect);
  304.  
  305.     DrawBoard();
  306.     DrawInfo();
  307. }
  308.  
  309. /*
  310.  
  311. Update the contents of the given window
  312. ############################   UpdateWindow   ##########################
  313.  
  314.    This is our response to receipt of an update event for myWindow.
  315.    Since the window is likely to be inactive, the current grafPort
  316.    will be elsewhere.  We must change it for drawing, yet leave it
  317.    as it was.
  318. */
  319.  
  320. UpdateWindow (awindow)
  321. WindowPtr awindow;
  322. {
  323.     GrafPtr saveport;    /* to save and restore the old port */
  324.  
  325.     BeginUpdate(awindow);    /* reset ClipRgn etc to only redraw what's */
  326.                 /* necessary. */
  327.  
  328.     GetPort(&saveport);    /* don't trash the port; we might be */
  329.                 /* updating an inactive window */
  330.  
  331.     SetPort(awindow);    /* work in the specified window */
  332.     DrawWindow();        /* redraw contents of window */
  333.  
  334.     SetPort(saveport);    /* all nice and tidy as before */
  335.     EndUpdate(awindow);
  336.  
  337. }
  338.  
  339.  
  340.  
  341. /* 
  342. Change the size of the given window
  343. ############################   ReSize   ###############################
  344.   
  345.   Called on a mouse-down in the grow box, this allows the user to change
  346.   the size of the window.  We change the size, then
  347.   claim that the whole of the window contents is no longer validly drawn,
  348.   because we're too lazy to do so for just the scroll bar regions
  349.   that are actually subject to change.  See the Window Manager.
  350. */
  351.  
  352. resize (awindow, downpt)
  353. WindowPtr awindow;
  354. Point * downpt;
  355. {
  356.     int     ww;
  357.     int     wh;        /* new width and height of the sized window */
  358.     long    newsize;    /* the new size */
  359.  
  360.     newsize = GrowWindow (awindow, downpt, &GrowRect);
  361.     /* find new size */
  362.     ww = LoWord (newsize);    /* find the width */
  363.     wh = HiWord (newsize);    /* find the height */
  364.  
  365.     SizeWindow (awindow, ww, wh, 1);/* change to the new window size */
  366.  
  367.     /* place whole window into update region to be sure it all gets */
  368.     /* updated. This is more than is strictly necessary, but a lot */
  369.     /* easier than just invalidating the regions that actually may have */
  370.     /* changed. */
  371.     InvalRect (&awindow -> portRect);
  372. }
  373.  
  374.  
  375.  
  376.  
  377. /* 
  378. the main loop that handles events
  379. ############################   MainEventLoop  ##########################
  380.   
  381.   Brace yourself: here's where the action is.  Most Mac programs just
  382.   wait for events (as do we all), and then process them.  There are
  383.   two sorts of events: those directly initiated by the user, like key
  384.   presses and mouse-downs, and those consequent events posted by the
  385.   Event Manager, like update and activate events.  The latter MUST be
  386.   handled correctly and carefully.  In particular, it's important for
  387.   all events to make sure that the event occurred in or for the window
  388.   you expect -- it's possible to get events which are not for one of
  389.   our windows, despite GetNextEvent's return value.  Similarly,
  390.   be sure to check that the window it occured in is the active one,
  391.   if it matters.
  392.   
  393.   A common mistake in handling update and activate events is in finding
  394.   out which window they are for.  It is "(WindowPtr)event.message "
  395.   that gives this information, NOT "whichWindow" (the WindowPtr returned
  396.   by FindWindow).  The latter pointer merely tells you what window
  397.   the mouse was in at the time the event was posted -- completely
  398.   irrelevant for Update and Activate events.  Think it through carefully.
  399.   
  400. */
  401.  
  402. DoEvent()
  403. {
  404.  
  405.     EventRecord event;
  406.  
  407.     /* body of DoEvent */
  408.  
  409.     /* get next event and handle it appropriately */
  410.  
  411.     SystemTask();        /* handle desk accessories */
  412.  
  413.     /* Get event, return if no event */
  414.     if (!GetNextEvent(everyEvent, &event))
  415.         return;
  416.  
  417.     switch (event.what) {    /* handle each kind of event */
  418.         case mouseDown: 
  419.             doMouse(&event);
  420.             break;    /* switch */
  421.  
  422.         case keyDown: 
  423.         case autoKey: 
  424.             doAutoKey(&event);
  425.             break;    /* wasn't here before */
  426.  
  427.         case updateEvt: /* if it's for our window, update it */
  428.             doUpdate(&event);
  429.             break;
  430.  
  431.         case activateEvt: 
  432.             doActivate(&event);
  433.             break;
  434.     }
  435. }
  436.  
  437.  
  438.  
  439. /* find out what window the mouse went down in, and where in it */
  440.  
  441. void
  442. doMouse(event)
  443. EventRecord *event;
  444. {
  445.     WindowPtr whichWindow;    /* points to window of MouseDown */
  446.     int windowcode;        /* what mouse was in when event posted */
  447.     MoveRecord    move;
  448.  
  449.     windowcode = FindWindow (&event->where, &whichWindow);
  450.     switch (windowcode) {
  451.                 /* handle mouse-down for each place */
  452.         case inSysWindow: 
  453.             /* handle the desk accessories */
  454.             SystemClick (event, whichWindow);
  455.             break;
  456.         case inMenuBar:
  457.             /* handle the command */
  458.             doCommand (MenuSelect (&event->where));
  459.                 break;
  460.         case inDrag:
  461.             /* drag the window */
  462.             DragWindow(whichWindow, &event->where, &DragRect);
  463.             break;
  464.         case inContent: 
  465.             /* includes inGrow if window inactive. */
  466.             /* Activate window */
  467.             /* make sure it's for mine */
  468.             if (whichWindow != myWindow)
  469.                 break;
  470.             if (whichWindow != FrontWindow()) { /* activate it */
  471.                 SelectWindow (whichWindow);
  472.                 break;
  473.             }
  474.             if (GameOver)
  475.                 break;
  476.             if (nClicks++ > 0)
  477.                 break;
  478.             StopThinking = FALSE;
  479.             GlobalToLocal(&event->where);
  480.             if (player[curColor] == Macintosh)
  481.                 DoMove(move);
  482.             else if (GetMove(&event->where, &move)) {
  483.                 DoMove(move);
  484.                 if (player[curColor] == Macintosh)
  485.                     DoMove(move);
  486.             }
  487.             while (--nClicks > 0) {    /* Handle mouse-ahead.    */
  488.                 if (GameOver || StopThinking ||
  489.                     player[curColor] != Macintosh)
  490.                     break;
  491.                 UpdateInfo();
  492.                 DoMove(move);
  493.             }
  494.             nClicks = 0;
  495.             UpdateInfo();
  496.                 break;
  497.         case inGrow: 
  498.             /* window is already active; change its  size */
  499.             /* make sure it's for mine */
  500. /*                if (whichWindow == myWindow)
  501.                 resize (myWindow, &event->where); */
  502.                 break;
  503.         case inGoAway: 
  504.             /* we don't have a GoAway region */
  505.             if (TrackGoAway(whichWindow, &event->where))
  506.                 ExitToShell();
  507.             break;
  508.     }
  509. }
  510.  
  511. /*
  512.  * activate event handling
  513.  *
  514. */
  515. void
  516. doActivate(event)
  517. EventRecord *event;
  518. {
  519.     /* if for our window, set port as nec. */
  520.     if ((WindowPtr)(event->message) != myWindow) 
  521.         return;
  522.     /* my window */
  523.  
  524. /*    DrawGrowIcon (myWindow); */
  525.     /* redraw grow icon to reflect new state */
  526.  
  527.     if (event->modifiers & 1)    /* odd means an activate event */
  528.         SetPort (myWindow);
  529.     else                /* act. evt: work in our own port */
  530.  
  531.         SetPort (ScreenPort);
  532.         /* deactivate evt: our port is gone; keep port from dangling */
  533. }
  534.  
  535. /*
  536.  * update event handling
  537.  *
  538. */
  539. void
  540. doUpdate(event)
  541. EventRecord *event;
  542. {
  543.     if ((WindowPtr) (event->message) == myWindow)
  544.         UpdateWindow (myWindow);  /* redraw the window contents */
  545. }
  546.  
  547. /*
  548.  * autokey event handling 
  549. */
  550. /* if command key, pass the char to MenuKey */
  551. void
  552. doAutoKey(event)
  553. EventRecord *event;
  554. {
  555.         if ((event->modifiers & cmdKey) != 0) 
  556.         doCommand(MenuKey((char)(event->message&CHARCODEMASK)));
  557. }
  558.  
  559.  
  560.  
  561.  
  562. /*
  563.   body of Skel
  564. */
  565.  
  566.  
  567. main()
  568. {
  569.     SetUp();
  570.     FlushEvents(everyEvent, 0);    /* discard leftover events */
  571.     while (TRUE)
  572.         DoEvent();
  573. }
  574.